{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 19 - 评估因果模型\n",
    "\n",
    "在绝大多数关于因果关系的材料中，研究人员使用合成数据来检查他们的方法是否有效。就像我们在“当预测失败时”一章中所做的那样，他们在 \\\\(Y_{0i}\\\\) 和 \\\\(Y_{1i}\\\\) 上生成数据，以便他们可以检查他们的模型是否正确捕获了干预效果 \\\\(Y_{1i} - Y_{0i}\\\\)。这对于学术目的来说很好，但在现实世界中，我们没有那么奢侈的待遇。在工业界中应用这些技术时，我们会一次又一次地被问到为什么我们的模型更好，为什么要在生产中替换当前的模型，或者为什么它不会惨遭失败。这非常重要，以至于我无法理解为什么我们没有看到任何解释我们应该如何用真实数据评估因果推理模型的材料。\n",
    "\n",
    "因此，想要应用因果推理模型的数据科学家很难说服管理层信任他们。他们采用的方法之一是展示理论的合理性以及他们在训练模型时的谨慎程度。不幸的是，在一个以训练-测试分割范式为常态的世界中，这么做没有什么用。你的模型的质量必须建立在比漂亮的理论更具体的东西上。想想看，机器学习之所以取得巨大成功，是因为预测模型的验证非常直接。看到预测与实际发生的情况相符，这让人放心。\n",
    "\n",
    "不幸的是，在因果推理的情况下，我们如何实现像训练-测试范式这样的东西并不明显。这是因为因果推理对估计一个不可观察的量感兴趣，\\\\(\\frac{\\delta y}{ \\delta t}\\\\)。好吧，如果我们看不到它，我们怎么知道我们的模型是否擅长估计它呢？请记住，就好像每个实体都有潜在的，用从干预到结果的估计线的斜率表示的反应，但我们无法衡量它。\n",
    "\n",
    "![img](./data/img/evaluate-causal-models/sneak.png)\n",
    "\n",
    "这是一件非常非常非常困难的事情，我花了很多年才找到接近答案的东西。不是一个确定的模型，但它在实践中有效，并且很具体，我希望它能够从类似于机器学习的训练-测试范式中进行因果推理。诀窍是使用弹性的聚合测量。即使你不能单独估计弹性，你也可以为一个群体做，这就是我们将在这里利用的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns\n",
    "from toolz import curry\n",
    "\n",
    "import statsmodels.formula.api as smf\n",
    "import statsmodels.api as sm\n",
    "\n",
    "from sklearn.ensemble import GradientBoostingRegressor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在本章中，我们将使用非随机数据来估计我们的因果模型，并使用随机数据来评估它。 同样，我们将讨论价格如何影响冰淇淋销售。 正如我们将看到的，随机数据对于评估目的非常有价值。 然而，在现实生活中，收集随机数据通常是昂贵的（如果你知道其中一些价格不是很好，只会让你赔钱，为什么还要随机定价？？？）。 最终发生的情况是，我们经常拥有大量数据，其中处理**不是**随机的，而随机数据（如果有的话）非常少。 由于使用非随机数据评估模型非常棘手，因此如果我们有任何随机数据，我们倾向于将其留作评估目的。\n",
    "\n",
    "以防万一您忘记了，这是数据的样子。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5000, 5)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>temp</th>\n",
       "      <th>weekday</th>\n",
       "      <th>cost</th>\n",
       "      <th>price</th>\n",
       "      <th>sales</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>17.3</td>\n",
       "      <td>6</td>\n",
       "      <td>1.5</td>\n",
       "      <td>5.6</td>\n",
       "      <td>173</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>25.4</td>\n",
       "      <td>3</td>\n",
       "      <td>0.3</td>\n",
       "      <td>4.9</td>\n",
       "      <td>196</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>23.3</td>\n",
       "      <td>5</td>\n",
       "      <td>1.5</td>\n",
       "      <td>7.6</td>\n",
       "      <td>207</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>26.9</td>\n",
       "      <td>1</td>\n",
       "      <td>0.3</td>\n",
       "      <td>5.3</td>\n",
       "      <td>241</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>20.2</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>7.2</td>\n",
       "      <td>227</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   temp  weekday  cost  price  sales\n",
       "0  17.3        6   1.5    5.6    173\n",
       "1  25.4        3   0.3    4.9    196\n",
       "2  23.3        5   1.5    7.6    207\n",
       "3  26.9        1   0.3    5.3    241\n",
       "4  20.2        1   1.0    7.2    227"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prices = pd.read_csv(\"./data/ice_cream_sales.csv\") # loads non-random data\n",
    "prices_rnd = pd.read_csv(\"./data/ice_cream_sales_rnd.csv\") # loads random data\n",
    "print(prices_rnd.shape)\n",
    "prices.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "出于比较目的，让我们训练两个模型。 第一个将是具有交互项的线性回归，以便允许弹性在单位之间变化。\n",
    "\n",
    "$$\n",
    "sales_i = \\beta_0 + \\beta_1 price_i + \\pmb{\\beta_2 X}_i + \\pmb{\\beta_3 X}_i price_i + e_i\n",
    "$$\n",
    "\n",
    "一旦我们拟合了这个模型，我们将能够进行弹性预测。\n",
    "\n",
    "$$\n",
    "\\widehat{\\frac{\\delta sales}{ \\delta price}} = \\hat{\\beta_1} + \\pmb{\\hat{\\beta_3} X}_i\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "m1 = smf.ols(\"sales ~ price*cost + price*C(weekday) + price*temp\", data=prices).fit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第二个模型将是完全非参数、基于机器学习的预测模型：\n",
    "\n",
    "$$\n",
    "sales_i = G(X_i, price_i) + e_i\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = [\"temp\", \"weekday\", \"cost\", \"price\"]\n",
    "y = \"sales\"\n",
    "\n",
    "np.random.seed(1)\n",
    "m2 = GradientBoostingRegressor()\n",
    "m2.fit(prices[X], prices[y]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了确保模型没有严重过度拟合，我们可以比较我们使用训练它的数据的到的\\\\(R^2\\\\)和使用新的、看不见的数据得到的 \\\\(R^2\\\\)。 （对于那些更精通机器学习的人，请注意性能会有所下降，因为存在概念漂移。模型是在价格不是随机的数据中训练的，但测试集只有随机价格）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Score: 0.9251704824568053\n",
      "Test Score: 0.7711074163447711\n"
     ]
    }
   ],
   "source": [
    "print(\"Train Score:\", m2.score(prices[X], prices[y]))\n",
    "print(\"Test Score:\", m2.score(prices_rnd[X], prices_rnd[y]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在训练我们的模型之后，我们将从回归模型中获得弹性。 同样，我们将求助于数值近似\n",
    "\n",
    "$$\n",
    "\\frac{\\delta y(t)}{\\delta t} \\approx \\frac{y(t+h) - y(t)}{h}\n",
    "$$\n",
    "\n",
    "我们的模型接受了非随机数据的训练。 现在我们转向随机数据进行预测。 就这样我们将所有东西都放在一个地方，我们将把机器学习模型的预测和因果模型的弹性预测添加到单个数据帧“prices_rnd_pred”中。\n",
    "\n",
    "此外，我们还包括一个随机模型。 这个想法是这个模型只输出随机数作为预测。 它显然不是很有用，但它可以很好地作为基准。 每当我们谈论进行评估的新方法时，我总是喜欢思考随机（无用）模型会如何做。 如果随机模型能够在评估标准上表现良好，那就说明评估方法的真正好坏。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>temp</th>\n",
       "      <th>weekday</th>\n",
       "      <th>cost</th>\n",
       "      <th>price</th>\n",
       "      <th>sales</th>\n",
       "      <th>m1_pred</th>\n",
       "      <th>m2_pred</th>\n",
       "      <th>m3_pred</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>25.8</td>\n",
       "      <td>1</td>\n",
       "      <td>0.3</td>\n",
       "      <td>7</td>\n",
       "      <td>230</td>\n",
       "      <td>224.067406</td>\n",
       "      <td>-13.096964</td>\n",
       "      <td>0.696469</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>22.7</td>\n",
       "      <td>3</td>\n",
       "      <td>0.5</td>\n",
       "      <td>4</td>\n",
       "      <td>190</td>\n",
       "      <td>189.889147</td>\n",
       "      <td>1.054695</td>\n",
       "      <td>0.286139</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>33.7</td>\n",
       "      <td>7</td>\n",
       "      <td>1.0</td>\n",
       "      <td>5</td>\n",
       "      <td>237</td>\n",
       "      <td>237.255157</td>\n",
       "      <td>-17.362642</td>\n",
       "      <td>0.226851</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>23.0</td>\n",
       "      <td>4</td>\n",
       "      <td>0.5</td>\n",
       "      <td>5</td>\n",
       "      <td>193</td>\n",
       "      <td>186.688619</td>\n",
       "      <td>0.564985</td>\n",
       "      <td>0.551315</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>24.4</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>3</td>\n",
       "      <td>252</td>\n",
       "      <td>250.342203</td>\n",
       "      <td>-13.717946</td>\n",
       "      <td>0.719469</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   temp  weekday  cost  price  sales     m1_pred    m2_pred   m3_pred\n",
       "0  25.8        1   0.3      7    230  224.067406 -13.096964  0.696469\n",
       "1  22.7        3   0.5      4    190  189.889147   1.054695  0.286139\n",
       "2  33.7        7   1.0      5    237  237.255157 -17.362642  0.226851\n",
       "3  23.0        4   0.5      5    193  186.688619   0.564985  0.551315\n",
       "4  24.4        1   1.0      3    252  250.342203 -13.717946  0.719469"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def predict_elast(model, price_df, h=0.01):\n",
    "    return (model.predict(price_df.assign(price=price_df[\"price\"]+h))\n",
    "            - model.predict(price_df)) / h\n",
    "\n",
    "np.random.seed(123)\n",
    "prices_rnd_pred = prices_rnd.assign(**{\n",
    "    \"m1_pred\": m2.predict(prices_rnd[X]), ## predictive model\n",
    "    \"m2_pred\": predict_elast(m1, prices_rnd), ## elasticity model\n",
    "    \"m3_pred\": np.random.uniform(size=prices_rnd.shape[0]), ## random model\n",
    "})\n",
    "\n",
    "prices_rnd_pred.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 弹性模型带\n",
    "\n",
    "现在我们有了预测，我们需要评估它们的好坏。请记住，我们无法观察到弹性，因此没有可以比较的简单基本事实。相反，让我们回想一下我们想要从弹性模型中得到什么。也许这会给我们一些关于如何评估它们的见解。\n",
    "\n",
    "制作干预弹性模型的想法来自于需要找出哪些单位对干预更敏感，哪些更不敏感。它来自对个性化的渴望。也许营销活动只在一部分人群中非常有效。也许折扣只适用于某些类型的客户。一个好的因果模型应该可以帮助我们发现哪些客户对提议的干预反应更好和更差。他们应该能够将单位分成他们对干预的弹性或敏感程度。在我们的冰淇淋示例中，该模型应该能够计算出人们在哪几天愿意在冰淇淋上花费更多，或者在哪几天价格弹性的负值较小。\n",
    "\n",
    "如果这是目标，那么如果我们能以某种方式将单位从更敏感到不太敏感排序，那将非常有用。由于我们有预测的弹性，我们可以按该预测对单位进行排序，并希望它也按实际弹性对它们进行排序。遗憾的是，我们无法在单位级别上评估该排序。但是，如果我们不需要呢？相反，如果我们评估由排序定义的组怎么办？如果我们的处理是随机分布的（这是随机性进入的地方），那么估计一组单​​位的弹性很容易。我们所需要的只是比较干预与否的结果。\n",
    "\n",
    "为了更好地理解这一点，描绘二元处理案例很有用。让我们保留定价示例，但现在的干预量是折扣。换句话说，价格可以高（未处理）或低（处理）。让我们在 Y 轴上绘制销售额，在 X 轴上绘制我们的每个模型，并将价格作为颜色。然后，我们可以将模型轴上的数据分成三个大小相等的组。 **如果干预是随机分配的**，我们可以轻松估计每组的 ATE \\\\(E[Y|T=1] - E[Y|T=0]\n",
    "\\\\)。\n",
    "\n",
    "![img](./data/img/evaluate-causal-models/ate_bins.png)\n",
    "\n",
    "在图像中，我们可以看到第一个模型在预测销售额方面有些好（与销售额相关性高），但它产生的组具有大致相同的处理效果，如下图所示。三个部分中有两个具有相同的弹性，只有最后一个具有不同的较低弹性。\n",
    "\n",
    "另一方面，第二个模型产生的每一组都有不同的因果效应。这表明该模型确实可以用于个性化。最后，随机模型产生具有完全相同弹性的组。这不是很有用，但它是预期的。如果模型是随机的，则它产生的每个片段都是随机且具有代表性的数据样本。因此，其组中的弹性应该与整个数据集上的 ATE 大致相同。\n",
    "\n",
    "只需查看这些图，您就可以了解哪个模型更好。弹性看起来越有序，带之间的差异越大，越好。在这里，模型 2 可能比模型 1 更好，这可能比随机模型更好。\n",
    "\n",
    "为了将其推广到连续情况，我们可以使用单变量线性回归模型来估计弹性。\n",
    "\n",
    "$$\n",
    "y_i = \\beta_0 + \\beta_1t_i + e_i\n",
    "$$\n",
    "\n",
    "如果我们使用一组样本运行该模型，我们将估计该组内的弹性。\n",
    "\n",
    "根据简单线性回归的理论，我们知道\n",
    "\n",
    "$$\n",
    "\\hat{\\beta_1}=\\dfrac{\\sum (t_i - \\bar{t}) (y_i - \\bar{y})}{\\sum(t_i - \\bar{t})^2}\n",
    "$$\n",
    "\n",
    "其中 \\\\(\\bar{t}\\\\) 是处理的样本平均值，\\\\(\\bar{y}\\\\) 是结果的样本平均值。 这是代码中的样子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "@curry\n",
    "def elast(data, y, t):\n",
    "        # line coeficient for the one variable linear regression \n",
    "        return (np.sum((data[t] - data[t].mean())*(data[y] - data[y].mean())) /\n",
    "                np.sum((data[t] - data[t].mean())**2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在让我们将其应用于我们的冰淇淋价格数据。 为此，我们还需要一个函数，将数据集分割成大小相等的分区，并将弹性应用于每个分区。 以下代码将处理该问题。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def elast_by_band(df, pred, y, t, bands=10):\n",
    "    return (df\n",
    "            .assign(**{f\"{pred}_band\":pd.qcut(df[pred], q=bands)}) # makes quantile partitions\n",
    "            .groupby(f\"{pred}_band\")\n",
    "            .apply(elast(y=y, t=t))) # estimate the elasticity on each partition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，让我们使用我们之前所做的预测按波段绘制弹性。 在这里，我们将使用每个模型来构建分区，然后估计每个分区的弹性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1, 3, sharey=True, figsize=(10, 4))\n",
    "for m, ax in enumerate(axs):\n",
    "    elast_by_band(prices_rnd_pred, f\"m{m+1}_pred\", \"sales\", \"price\").plot.bar(ax=ax)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "首先，查看随机模型 (\\\\(m3\\\\))。它在每个分区中具有大致相同的估计弹性。通过查看该图，我们已经可以看出，它对个性化没有太大帮助，因为它无法区分高价格弹性日和低价格弹性日。接下来，考虑预测模型 \\\\(m1\\\\)。该模型实际上是有前途的！它设法构建弹性高的组和弹性低的组。这正是我们所需要的。\n",
    "\n",
    "最后，因果模型 \\\\(m2\\\\) 看起来有点奇怪。它识别出弹性非常低的群体，这里的低实际上意味着高价格敏感度（随着我们提高价格，销售额将大幅下降）。检测那些价格敏感的日子对我们非常有用。如果我们知道它们是什么时候，我们会小心不要在这些日子继续涨价。因果模型还识别了一些不太敏感的区域，因此它可以成功地区分高弹性和低弹性。但是排序不如预测模型好。\n",
    "\n",
    "那么，我们应该如何决定呢？哪个更有用？预测模型还是因果模型？预测模型具有更好的排序，但因果模型可以更好地识别极端情况。带状图的弹性是一个很好的初步检查，但它不能准确回答哪个模型更好。我们需要转向更精细的东西。\n",
    "\n",
    "## 累积弹性曲线\n",
    "\n",
    "再次考虑将价格转换为二元处理的说明性示例。我们会从我们离开的地方拿走它，所以我们有弹性处理带。我们接下来可以做的是根据乐队的敏感程度对乐队进行排序。也就是说，我们把最敏感的组放在第一位，第二个最敏感的组放在第二位，依此类推。对于模型 1 和 3，无需重新订购，因为它们已经订购。对于模型 2，我们必须颠倒排序。\n",
    "\n",
    "一旦我们有了有序的组，我们就可以构建我们称之为累积弹性曲线的东西。我们首先计算第一组的弹性；然后，第一个和第二个等等，直到我们包含所有组。最后，我们将只计算整个数据集的弹性。这是我们的说明性示例的外观。\n",
    "\n",
    "![img](./data/img/evaluate-causal-models/cumm_elast.png)\n",
    "\n",
    "请注意，累积弹性中的第一个 bin 只是根据该模型来自最敏感组的 ATE。此外，对于所有模型，累积弹性将收敛到同一点，即整个数据集的 ATE。\n",
    "\n",
    "在数学上，我们可以将累积弹性定义为直到单位 \\\\(k\\\\) 之前估计的弹性。\n",
    "\n",
    "$$\n",
    "\\widehat{y'(t)}_k = \\hat{\\beta_1}_k=\\dfrac{\\sum_i^k (t_i - \\bar{t}) (y_i - \\bar{y})}{\\sum_i^k (t_i - \\bar{t})^2}\n",
    "$$\n",
    "\n",
    "为了构建累积弹性曲线，我们在数据集中迭代地运行上述函数以产生以下序列。\n",
    "\n",
    "$$\n",
    "(\\widehat{y'(t)}_1, \\widehat{y'(t)}_2, \\widehat{y'(t)}_3,..., \\widehat{y'(t)}_N)\n",
    "$$\n",
    "\n",
    "就模型评估而言，这是一个非常有趣的序列，因为我们可以对其进行偏好陈述。首先，模型更好的程度\n",
    "\n",
    "$\\hat{y}'(t)_k > \\hat{y}'(t)_{k+a}$\n",
    "\n",
    "对于任何 \\\\(k\\\\) 和 \\\\(a>0\\\\)。换句话说，如果一个模型擅长对弹性进行排序，那么在前 \\\\(k\\\\) 个样本中观察到的弹性应该高于在前 \\\\(k+a\\\\) 个样本中观察到的弹性。或者，简单地说，如果我查看顶部单位，它们应该比它们下面的单位具有更高的弹性。\n",
    "\n",
    "其次，模型更好的程度\n",
    "\n",
    "$\\hat{y}'(t)_k - \\hat{y}'(t)_{k+a}$\n",
    "\n",
    "是最大的，对于任何 \\\\(k\\\\) 和 \\\\(a>0\\\\)。直觉是，我们不仅希望顶部 \\\\(k\\\\) 单位的弹性高于其下方单位的弹性，而且我们希望这种差异尽可能大。\n",
    "\n",
    "为了使其更具体，这是用代码表示的这个想法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cumulative_elast_curve(dataset, prediction, y, t, min_periods=30, steps=100):\n",
    "    size = dataset.shape[0]\n",
    "    \n",
    "    # orders the dataset by the `prediction` column\n",
    "    ordered_df = dataset.sort_values(prediction, ascending=False).reset_index(drop=True)\n",
    "    \n",
    "    # create a sequence of row numbers that will define our Ks\n",
    "    # The last item is the sequence is all the rows (the size of the dataset)\n",
    "    n_rows = list(range(min_periods, size, size // steps)) + [size]\n",
    "    \n",
    "    # cumulative computes the elasticity. First for the top min_periods units.\n",
    "    # then for the top (min_periods + step*1), then (min_periods + step*2) and so on\n",
    "    return np.array([elast(ordered_df.head(rows), y, t) for rows in n_rows])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "关于此功能的一些注意事项。 它假定对弹性进行排序的事物存储在传递给“预测”参数的列中。 此外，第一组有 `min_periods` 单位，因此它可以与其他组不同。 原因是，由于样本量小，弹性在曲线开始时可能过于嘈杂。 为了解决这个问题，我们可以传递一个已经足够大的第一组。 最后，`steps` 参数定义了我们在每个后续组中包含多少额外单元。\n",
    "\n",
    "使用此功能，我们现在可以根据每个模型产生的顺序绘制累积弹性曲线。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "\n",
    "for m in range(3):\n",
    "    cumu_elast = cumulative_elast_curve(prices_rnd_pred, f\"m{m+1}_pred\", \"sales\", \"price\", min_periods=100, steps=100)\n",
    "    x = np.array(range(len(cumu_elast)))\n",
    "    plt.plot(x/x.max(), cumu_elast, label=f\"M{m+1}\")\n",
    "\n",
    "plt.hlines(elast(prices_rnd_pred, \"sales\", \"price\"), 0, 1, linestyles=\"--\", color=\"black\", label=\"Avg. Elast.\")\n",
    "plt.xlabel(\"% of Top Elast. Days\")\n",
    "plt.ylabel(\"Cumulative Elasticity\")\n",
    "plt.title(\"Cumulative Elasticity Curve\")\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "解释累积弹性曲线可能有点挑战性，但这是我的看法。同样，考虑二分类情况可能更容易。曲线的 X 轴代表我们正在处理的样本数量。在这里，我将轴归一化为数据集的比例，所以 0.4 意味着我们正在处理 40% 的样本。 Y 轴是我们在这么多样本上应该预期的弹性。因此，如果一条曲线在 40% 处的值为 -1，则意味着前 40% 单位的弹性为 -1。理想情况下，我们希望尽可能大的样本具有最高的弹性。理想的曲线将在 Y 轴上从高处开始，然后非常缓慢地下降到平均弹性，这表示我们可以处理高百分比的单位，同时仍保持高于平均弹性。\n",
    "\n",
    "不用说，我们的模型都没有接近理想的弹性曲线。随机模型 \\\\(M3\\\\) 围绕平均弹性波动，并且永远不会离它太远。这意味着该模型无法找到弹性与平均弹性不同的组。至于预测模型 \\\\(M1\\\\)，它似乎是反向排序的弹性，因为曲线从低于平均弹性开始。不仅如此，它还在大约 50% 的样本处很快收敛到平均弹性。最后，因果模型 \\\\(M2\\\\) 似乎更有趣。一开始它有这种奇怪的行为，累积弹性增加远离平均值，但随后它达到了一个点，我们可以处理大约 75% 的单位，同时保持几乎为 0 的相当不错的弹性。这可能是因为这个模型可以识别非常低弹性（高价格敏感度）的日子。因此，如果我们在那些日子不提价，我们可以对大部分样本（约 75%）进行提价，同时价格敏感度仍然较低。\n",
    "\n",
    "在模型评估方面，累积弹性曲线（Cumulative Elasticity Curve） 已经远远好于简单的分区间的弹性概念。在这里，我们设法对我们的模型做出更精确的偏好陈述。不过，这是一条复杂的曲线，难以理解。出于这个原因，我们可以做进一步的改进。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 累积增益曲线\n",
    "\n",
    "下一个想法是在累积弹性之上进行非常简单但强大的改进。我们将累积弹性乘以比例样本量。例如，如果累积弹性在 40% 时为 -0.5，那么此时我们将得到 -0.2 (-0.5 * 0.4)。然后，我们将其与随机模型产生的理论曲线进行比较。这条曲线实际上是一条从 0 到平均干预效果的直线。可以这样想：随机模型的累积弹性中的每个点都是 ATE，因为该模型只生成数据的随机代表性分区。如果在 (0,1) 线上的每一点，我们将 ATE 乘以该点，我们最终会得到一条介于 0 和 ATE 之间的直线。\n",
    "\n",
    "![img](./data/img/evaluate-causal-models/cumm_gain.png)\n",
    "\n",
    "一旦我们有了理论上的随机曲线，我们就可以将其用作基准，并将我们的其他模型与它进行比较。所有曲线将在同一点开始和结束。然而，模型的弹性排序越好，曲线在零到一之间的点处偏离随机线的程度就越大。例如，在上图中，M2 优于 M1，因为它在到达终点 ATE 之前发散得更多。对于熟悉 ROC 曲线的人，您可以将累积增益视为因果模型的 ROC。\n",
    "\n",
    "从数学上讲，\n",
    "\n",
    "$$\n",
    "\\widehat{F(t)}_k = \\hat{\\beta_1}_k * \\frac{k}{N} =\\dfrac{\\sum_i^k (t_i - \\bar{t}) (y_i - \\bar{y })}{\\sum_i^k(t_i - \\bar{t})^2} * \\frac{k}{N}\n",
    "$$\n",
    "\n",
    "\n",
    "要在代码中实现它，我们所要做的就是添加比例样本大小归一化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cumulative_gain(dataset, prediction, y, t, min_periods=30, steps=100):\n",
    "    size = dataset.shape[0]\n",
    "    ordered_df = dataset.sort_values(prediction, ascending=False).reset_index(drop=True)\n",
    "    n_rows = list(range(min_periods, size, size // steps)) + [size]\n",
    "    \n",
    "    ## add (rows/size) as a normalizer. \n",
    "    return np.array([elast(ordered_df.head(rows), y, t) * (rows/size) for rows in n_rows])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用我们的冰激凌数据，我们会得到如下曲线。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "\n",
    "for m in range(3):\n",
    "    cumu_gain = cumulative_gain(prices_rnd_pred, f\"m{m+1}_pred\", \"sales\", \"price\", min_periods=50, steps=100)\n",
    "    x = np.array(range(len(cumu_gain)))\n",
    "    plt.plot(x/x.max(), cumu_gain, label=f\"M{m+1}\")\n",
    "    \n",
    "plt.plot([0, 1], [0, elast(prices_rnd_pred, \"sales\", \"price\")], linestyle=\"--\", label=\"Random Model\", color=\"black\")\n",
    "\n",
    "plt.xlabel(\"% of Top Elast. Days\")\n",
    "plt.ylabel(\"Cumulative Gain\")\n",
    "plt.title(\"Cumulative Gain\")\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在很清楚，因果模型（M2）比其他两个要好得多。它与随机线的差异远大于 M1 和 M3。此外，请注意随机模型 M3 如何非常接近理论随机模型。两者之间的区别可能只是随机噪声。\n",
    "\n",
    "有了这个，我们介绍了一些关于如何评估因果模型的非常好的想法。仅此一项就是一件大事。即使我们没有要比较的基本事实，我们也设法评估了模型在排序弹性方面的好坏。只缺少最后一件事，即包括围绕这些测量值的置信区间。毕竟，我们不是野蛮人，不是吗？\n",
    "\n",
    "![img](./data/img/evaluate-causal-models/uncivilised.png)\n",
    "\n",
    "\n",
    "## 考虑差异\n",
    "\n",
    "当我们处理弹性曲线时，不考虑方差是错误的。特别是由于它们都使用线性回归理论，因此在它们周围添加置信区间应该相当容易。\n",
    "\n",
    "为此，我们将首先创建一个函数，该函数返回线性回归参数的 CI。我在这里使用简单线性回归的公式，但可以随意提取 CI。\n",
    "\n",
    "$$\n",
    "s_{\\hat\\beta_1}=\\sqrt{\\frac{\\sum_i\\hat\\epsilon_i^2}{(n-2)\\sum_i(t_i-\\bar t)^2}}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def elast_ci(df, y, t, z=1.96):\n",
    "    n = df.shape[0]\n",
    "    t_bar = df[t].mean()\n",
    "    beta1 = elast(df, y, t)\n",
    "    beta0 = df[y].mean() - beta1 * t_bar\n",
    "    e = df[y] - (beta0 + beta1*df[t])\n",
    "    se = np.sqrt(((1/(n-2))*np.sum(e**2))/np.sum((df[t]-t_bar)**2))\n",
    "    return np.array([beta1 - z*se, beta1 + z*se])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过对我们的`cumulative_elast_curve`函数进行一些小的修改，我们可以输出弹性的置信区间。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cumulative_elast_curve_ci(dataset, prediction, y, t, min_periods=30, steps=100):\n",
    "    size = dataset.shape[0]\n",
    "    ordered_df = dataset.sort_values(prediction, ascending=False).reset_index(drop=True)\n",
    "    n_rows = list(range(min_periods, size, size // steps)) + [size]\n",
    "    \n",
    "    # just replacing a call to `elast` by a call to `elast_ci`\n",
    "    return np.array([elast_ci(ordered_df.head(rows), y, t)  for rows in n_rows])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，这是因果 (M2) 模型的 95% CI 的累积弹性曲线。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "\n",
    "cumu_gain_ci = cumulative_elast_curve_ci(prices_rnd_pred, \"m2_pred\", \"sales\", \"price\", min_periods=50, steps=200)\n",
    "x = np.array(range(len(cumu_gain_ci)))\n",
    "plt.plot(x/x.max(), cumu_gain_ci, color=\"C0\")\n",
    "\n",
    "plt.hlines(elast(prices_rnd_pred, \"sales\", \"price\"), 0, 1, linestyles=\"--\", color=\"black\", label=\"Avg. Elast.\")\n",
    "\n",
    "plt.xlabel(\"% of Top Elast. Days\")\n",
    "plt.ylabel(\"Cumulative Elasticity\")\n",
    "plt.title(\"Cumulative Elasticity for M2 with 95% CI\")\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意随着我们积累更多的数据集，CI 是如何变得越来越小的。 那是因为样本量增加了。\n",
    "\n",
    "至于累积增益曲线，获取 CI 也同样简单。 同样，我们只是将调用 `elast` 函数替换为调用 `elast_ci` 函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cumulative_gain_ci(dataset, prediction, y, t, min_periods=30, steps=100):\n",
    "    size = dataset.shape[0]\n",
    "    ordered_df = dataset.sort_values(prediction, ascending=False).reset_index(drop=True)\n",
    "    n_rows = list(range(min_periods, size, size // steps)) + [size]\n",
    "    return np.array([elast_ci(ordered_df.head(rows), y, t) * (rows/size) for rows in n_rows])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这是因果模型的样子。 请注意，现在 CI 开始时很小，即使曲线开始时的样本量较小。 原因是归一化因子 \\\\(\\frac{k}{N}\\\\) 回避了 ATE 参数，并且它是 CI。 由于这条曲线应该用于比较模型，所以这应该不是问题，因为曲线会将这个推卸因子平等地应用于所有正在评估的模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,6))\n",
    "\n",
    "cumu_gain = cumulative_gain_ci(prices_rnd_pred, \"m2_pred\", \"sales\", \"price\", min_periods=50, steps=200)\n",
    "x = np.array(range(len(cumu_gain)))\n",
    "plt.plot(x/x.max(), cumu_gain, color=\"C0\")\n",
    "\n",
    "plt.plot([0, 1], [0, elast(prices_rnd_pred, \"sales\", \"price\")], linestyle=\"--\", label=\"Random Model\", color=\"black\")\n",
    "\n",
    "plt.xlabel(\"% of Top Elast. Days\")\n",
    "plt.ylabel(\"Cumulative Gain\")\n",
    "plt.title(\"Cumulative Gain for M2 with 95% CI\")\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 关键思想\n",
    "\n",
    "在这里，我们看到了三种方法来检查模型在排序弹性方面的好坏。我们使用这些方法来比较和决定具有因果关系的模型。这是非常重要的。我们已经设法检查了一个模型是否擅长识别具有不同弹性的组，即使无法看到弹性！\n",
    "\n",
    "在这里，我们严重依赖随机数据。我们在非随机数据上训练了模型，但所有评估都是在随机处理的样本上完成的。那是因为我们需要某种方法来自信地估计弹性。如果没有随机数据，我们在这里使用的简单公式将不起作用。正如我们现在非常清楚的那样，简单的线性回归在存在混杂变量的情况下忽略了变量偏差。\n",
    "\n",
    "尽管如此，如果我们能够掌握一些随机数据，我们就已经知道如何比较随机模型了。在下一章中，我们将解决非随机数据的问题，但在开始之前，我最后想说一些关于模型评估的想法。\n",
    "\n",
    "让我们重申一下可信赖模型评估的重要性。通过累积增益曲线，我们终于有了一种比较用于因果推理的模型的好方法。我们现在可以决定哪种模型更适合个性化干预。这是非常重要的。您会在因果推理中找到的大多数材料都没有为我们提供进行模型评估的好方法。在我看来，这是我们需要让因果推理像机器学习一样流行的缺失部分。通过良好的评估，我们可以使因果推理更接近已经对预测模型非常有用的训练测试范式。这是一个大胆的声明。这意味着我提到这个的时候很小心，但直到现在，我还没有找到任何好的点评。如果你有一些想法，请告诉我。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
